SIU.c

Go to the documentation of this file.

#include "derivative.h"
#include "SIU.h"
/*
 ******************************************************************************
 * Constants
 ******************************************************************************
 */
/*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
/*
 ******************************************************************************
 * vfnConfigDefaultPinBehavior
 ******************************************************************************
 */
void vfnConfigDefaultPinBehavior(const uint16_t* pu16Config, uint8_t u8Offset, \
                                 uint8_t u8ConfigSize)
{
  /* Local variables */
  uint8_t u8Counter;
  
  /* Make sure Pin is not higher than max available */
  if(PIN_CONFIG_REGISTER_MAX < (u8ConfigSize + u8Offset))
  {
    u8ConfigSize = PIN_CONFIG_REGISTER_MAX - u8Offset;
  }
  else
  {
    /* Proceed */
  }
  
  for(u8Counter = CLEAR; u8Counter < u8ConfigSize; u8Counter++)
  {
    SIU.PCR[u8Counter + u8Offset].R = *pu16Config;
    pu16Config++;
  }
  
  return;
}
/*
 ******************************************************************************
 * vfnToggleOutputPin
 ******************************************************************************
 */
void vfnToggleOutputPin(const uint8_t u8Port, const uint8_t u8Pin, \
                        const uint8_t u8Level)
{
  SIU.GPDO[u8fnReturnPinIndex(u8Port, u8Pin)].B.PDO = (CLEAR < u8Level);
  
  return;
}
/*
 ******************************************************************************
 * u8fnReadPin
 ******************************************************************************
 */
uint8_t u8fnReadPin(const uint8_t u8Port, const uint8_t u8Pin)
{
  uint8_t u8PCRPinIndex;
  uint8_t u8PinLevel;
  
  /* Figure out what the index is for PCR */
  u8PCRPinIndex = u8fnReturnPinIndex(u8Port, u8Pin);
  u8PinLevel = SIU_INVALID_PIN_CONFIGURATION;

  /* Depending on configuration (input, output), return value */
  if(TRUE == SIU.PCR[u8PCRPinIndex].B.IBE)
  {
    /* If configured for input, read input register */
    u8PinLevel = SIU.GPDI[u8PCRPinIndex].B.PDI;
  }
  else if(TRUE == SIU.PCR[u8PCRPinIndex].B.OBE)
  {
    /* Else, if configured as output, read output register */
    u8PinLevel = SIU.GPDO[u8PCRPinIndex].B.PDO;
  }
  else
  {
    /* Don't do anything - we will return an error */
  }
  
  return(u8PinLevel);
}
/*
 ******************************************************************************
 * u8fnReturnPinIndex
 ******************************************************************************
 */
uint8_t u8fnReturnPinIndex(const uint8_t u8Port, const uint8_t u8Pin)
{
  /* Quick version */
  return((uint8_t)((u8Port - 'A') * N_PINS_PER_PORT) + u8Pin);
}
/*
 ******************************************************************************
 * u8fnRouteInputPad
 ******************************************************************************
 */
uint8_t u8fnRouteInputPad(const uint8_t u8Module, const uint8_t u8PinIndex)
{
  uint8_t u8Status;
  
  u8Status = PAD_DOES_NOT_EXIST;
  
  if(N_INPUT_PADS > u8Module)
  {
    SIU.PSMI[u8Module].B.PADSEL = u8PinIndex;
    u8Status = CLEAR;
  }
  else
  {
    /* Get out */
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnIRQConfig
 ******************************************************************************
 */
uint8_t u8fnIRQConfig(uint8_t u8Channel, IRQConfig_t tConfig)
{
        uint8_t u8Status;
        uint32_t u32ChannelMask;
        
        u8Status = CLEAR;
        
        /* All operations are performed through a mask to the channel */
        /* First of all, let's generate the mask */
        u32ChannelMask = BIT0 << u8Channel;
        
        /* We will now clear any pre-existing conditions  */
        SIU.ISR.R |= u32ChannelMask;
        
        /* Next we set config for falling and raising edge based on config. */
        if(CLEAR == tConfig.P.FallingEdgeEn)
        {
          SIU.IFEER.R &= (~u32ChannelMask);
        }
        else
        {
          SIU.IFEER.R |= (u32ChannelMask);
        }
        if(CLEAR == tConfig.P.RisingEdgeEn)
        {
          SIU.IREER.R &= (~u32ChannelMask);
        }
        else
        {
          SIU.IREER.R |= (u32ChannelMask);
        }
        
        /* Repeat the operation for the glitch filter */
        if(CLEAR == tConfig.P.GlitchFiltEn)
        {
    SIU.IFER.R &= (~u32ChannelMask);
        }
        else
        {
          SIU.IFER.R |= (u32ChannelMask);
        }
        
        /* Finally we set the IRQ enable based on config as well */
        if(CLEAR == tConfig.P.IRQEn)
        {
          SIU.IRER.R &= (~u32ChannelMask);
        }
        else
        {
          SIU.IRER.R |= (u32ChannelMask);
        }
        
        return(u8Status);
}
/*
 ******************************************************************************
 * vfnIRQClearIsr
 ******************************************************************************
 */
void vfnIRQClearIsrFlag(uint8_t u8Channel)
{
        SIU.ISR.R |= (BIT0 << u8Channel);
        
        return;
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */